Method, a computer system, and a computer product for configuring a virtual representation of an assembly of a plurality of components

ABSTRACT

The invention provides a method for configuring a virtual representation of an assembly of a plurality of components, by: I) storing a first set of data representing a plurality of categories of components, and, for each category, parameters and constraints defining limitations for configurations of each of the components, II) generating and storing a second set of data representing the assembly of a plurality of components, while respecting the constraints associated with each component and constraints for the assembly, and generating a third set of data representing a present configuration, III) repeating the step II) by: a) adding, to the second and third set of data, data which represent a component and which are derived from the first set of data, or b) deleting data representing a component of the second and third set of data, or c) amending data representing a previously added component of the second and third set of data, while respecting the constraints associated with each component and constraints for the assembly, so as to arrive at an updated version of the second and third set of data.

This application is the national phase under 35 U.S.C. §371 ofInternational Application No. PCT/DK02/00878 filed on Dec. 19, 2002, andclaims priority to Danish Application No. PA 2001 01937, filed Dec. 21,2001 and also to U.S. Provisional Application No. 60/343,304, filed onDec. 8, 2006, the entire contents of each of which are incorporatedherein by reference.

TECHNICAL FIELD

The present invention relates to configuring of systems with the aim ofsupporting real-time visualization of configuration problems for complexproducts. The invention provides a general method for formulating aproduct model by use of abstract components. The invention is useful ina runtime environment, e.g. electronic sales, for visual configurationof products with real-time visual feedback.

BACKGROUND OF THE INVENTION

The configuration of a product may be seen as the process of navigatinga parameter space to arrive at one configuration (of the product), oftencalled a variant of the product or a customized product.

In the present context, a parameter should be understood as one or moreproperties, usually stored in a variable in a computer program, of acomponent. For example, a component may have a material parameter towhich different values may be assigned, such as oak, beech, mahogany,teak, etc., a color parameter, such as blue, green, yellow, etc., a sizeparameter, such as small, medium or large, a light reflection parameter,such as shiny or mat, etc.

For example, a car has a finite state space. Its system of legalsolutions can be defined by a finite number of parameters and theprocess of configuring a car is equivalent to navigating in a finitestate space by choosing a value on each of the finite number ofparameters. In contrary, a kitchen is built from a varying number ofcabinets and accessories, and, hence is having a varying, and possiblyunlimited, parameter space depending on the number of cabinets. For eachnew cabinet In a kitchen the parameter space changes.

A more general example is buildable products. A buildable product is aproduct which consists of a number of subproducts, which can be builttogether (in some sense) to yield a whole. In a sense, most physicalproducts can be seen as buildable. However, a product is usually calledbuildable if the product is not strictly confined to a specific numberof items. This could be considered as different products having a verydiffering number and/or combinations of subproducts, which are builttogether. For example, a car will always have the same number of similaressential parts, like four wheels and one engine, while a kitchen'sessential parts comprise a differing number of cabinets. The buildingblocks may in themselves very well be configurable or buildableproducts.

It is usually difficult to build a satisfactory product model of mostbuildable products. One problem is to get a hold of the number ofvariations, since each building block is configurable but dependent onall the others. One way to get around this is to fix the number andcombinations of subproducts and then describe all interrelationships.

Furthermore, for many buildable products the connection betweensubproducts can often be of a very basic physical nature, which isdifficult or even impossible to describe in logical terms of the productmodel. For instance in a kitchen, the drawers of a cabinet have a veryclear logical (or structural) relationship with the cabinet its in; forexample there may be 3, 5 or 7 dependent on the size. However, therelationship between two cabinets in two different connection groups isnot necessarily known.

Therefore, several problems exist. Firstly, the combined overall logicalrules of a buildable product do not relate very well to the classicalproduct model description. Secondly, the interrelationships in buildableproducts are not easy to describe in terms of logical constraints.

Two types of configurators based on rules are known; search algorithms(e.g. using tree structures) or storing all valid combinations in adatabase, based on logic. Neither of these techniques addresses theproblems mentioned above. Moreover, many obvious and simple rules are ofa geometric nature or refer to the products geometric nature. They arevery hard to formulate in a logical language. Thus, it is an object ofthe invention to facilitate the building of products based on thecomponent principle, and to enable the creation of a product model.

SUMMARY OF THE INVENTION

In a first aspect, the invention provides a method for configuring, in amemory of a computer system, a virtual representation of an assembly ofa plurality of components, the method comprising the steps of:

-   -   storing, in a database of the computer system, a first set of        data representing a plurality of categories of components, and,        for each category, parameters and constraints defining        limitations for configurations of each of the components within        each of the categories, whereby all components in a category        have common parameters and constraints,    -   generating or defining a second set of data representing the        assembly of a plurality of components and representing a        configuration space of said plurality of components, and storing        the second set of data in a memory of the computer system, the        step of generating being performed while respecting the        constraints associated with each component and constraints for        the assembly, and generating a third set of data representing a        present configuration in the configuration space,    -   repeating the step of generating or defining by:        -   adding, to the second and third set of data, data which            represent a component of a category and which are derived            from the first set of data, or        -   deleting data representing a component of the second and            third set of data, or        -   amending data representing a previously added component of            the second and third set of data,    -   while respecting the constraints associated with each component        and constraints for the assembly, so as to arrive at an updated        version of the second set of data, and at an updated version of        the third set of data.

The repetitive generation of the second and third set of data allows fora product model, which is not limited by a confined number of componentsor a confined space. Further, by having constraints defining limitationsfor configurations of each of the components stored in a database and byrespecting these constraints while generating the second set of data,the need for storing all possible combinations of components iseliminated. Analogously, by automatically generating and preferablystoring data representing constraints for the assembly, a product modelmay be built in a flexible, memory and data processing efficient manner.

It should be understood that the updated version of the second set ofdata may be obtained in consequence of a change in the third set ofdata, so that when the step of generating is repeated, the third set ofdata is updated, e.g. in response to user input, whereby the second setof data is automatically updated.

At the step of generating the third set of data, the method may furthercomprise offering a plurality of components or component categories, andrepeating the step of offering, whereby, when the step of offering isrepeated, only selected components or component categories are offered.Thus, a user of the computer system may save time when configuring aproduct, and at the same time it is prevented that illegal ornot-allowed combinations of components are being generated.

Data representing components may comprise data representing parametersof the components, in which case the method further comprises, at thestep of generating the third set of data, offering a plurality ofparameters of components, whereby only selected parameters are offered,the selected parameters being selected in accordance with constraints ofcomponents in such a way that only possible and/or legal combinations ofcomponents and parameters are achievable.

Furthermore, at the step of offering components and/or parameter values,only components and/or parameter values, which respect constraintsassociated with each component, and which respect constraints for theassembly may be offered.

In the present context, a component should be interpreted not only asthe physical component but also or alternatively its data representationin the memory of the computer system, possibly including parametersand/or characteristics of the component.

The method may comprise visualizing, on a display device or printerassociated with the computer system, a graphical or physicalrepresentation of at least a part of the configuration space representedby the second set of data and/or at least a part of the configurationrepresented by the third set of data. The computer system may beconnected to a communications network, in which case the method mayfurther comprise:

-   -   sending the second and/or the third set of data, via the        communications network, to a further computer system, and    -   visualizing, on a monitor of said further computer system or any        other device for displaying, a graphical image of the        configuration space represented by the second set of data and/or        a graphical image of the configuration represented by the third        set of data.

Thus, data may be communicated via a communications network, such as theInternet or a Local Area Network (LAN), so that a user or potentialbuyer of a product, for example of a kitchen, may configure the productfrom a location remote from the location of the computer system.

The second set of data may further comprise data representingrelationships between related components and the type of relationshipsbetween components, whereby the second set of data also representsconnections between components.

During the step of generating, the step of adding may compriseconnecting components in an assembly and/or adding a component to theassembly. Analogously, the step of deleting may comprise disconnectingtwo components in the assembly and/or removing a component from theassembly. Finally, the step of amending may comprise at least one of:

-   -   amending data representing at least one component of the        assembly,    -   connecting two components of the assembly, and    -   disconnecting two components of the assembly.

In one embodiment of the invention, the step of generating comprisescreating a set of clusters, each cluster containing data representing asingle component as well as optionally at least one further componentwhich is related to the single component, whereby the set of clusterscontains data representing all components comprised in the virtualrepresentation. The relationship between components may be either aphysical or a logical relationship. A physical relationship may forexample comprise a physical connection between two components, whereas alogical relationship for example limits the possible parameters orparameter values which may be assigned to a component, for example thewood from which a kitchen door is made being limited to oak or beech,whereas other kitchen components may also be made from teak or mahogany.The second data may comprise data representing the type of relationshipbetween related components.

The second set of data may further comprise a separate data structure ora set of separate data structures which define(s) possible or allowedcombinations of components and/or parameter values, the separate datastructure or structures being included in the second set of data in sucha way that each separate data structure is associated with a particularcomponent, whereby at least one of the constraints of the particularcomponent may reflect said possible or allowed combinations ofcomponents and/or parameter values.

Thus, the separate data structure associated with the single componentmay define possible or allowed combinations of components of the clustercorresponding to the single component and/or parameter values of thecomponents of the cluster corresponding to the single component.

The separate data structure may preferably constitute a configurationdatabase in which data representing possible or allowed combinations ofcomponents and/or parameter values are stored.

The step of generating the second set of data may further comprise:

-   -   performing, for each cluster, a check of whether the data        representing a component of that cluster, are compatible with        constraints defined by mutually connected components in that        cluster, and if the check reveals non-compatibility:    -   amending the second set of data and/or the data representing the        component in question while respecting constraints conferred by        all mutually connected components.

The second set of data may further comprise data representing thegeometry of at least a part of the assembly, whereby the constraints ofthe components of this part of the assembly define constraints of ageometric nature on the parameters of the components.

Furthermore, the third set of data may represent a state of the presentconfiguration, and the method may comprise, at the step of repeating,automatically updating the second set of data in response to changes tothe third set of data. Such a change to the third set of data may forexample be altering the value of one or more parameters. In case aparameter is representing a component, alteration of such a parametermay initiate that the component is inserted/removed from the assemblyand/or that a connection involving the component is inserted/removed.Thus, the present configuration is reproducible from the first and thirdset of data.

In a second aspect, the invention relates to a computer system forconfiguring, in a memory of the computer system, a virtualrepresentation of an assembly of a plurality of components, the computersystem comprising:

-   -   a database storing a first set of data representing a plurality        of categories of components, and, for each category, parameters        and constraints defining limitations for configurations of each        of the components within each of the categories, whereby all        parameters and components in a category have common constraints,    -   a processor which is programmed to generate a second set of data        representing the assembly of a plurality of components and        representing a configuration space of said plurality of        components, and to store the second set of data in a memory of        the computer system, the processor being programmed to generate        the second set of data while respecting the constraints        associated with each component and constraints for the assembly,        the processor being further programmed to generate a third set        of data representing a present configuration in the        configuration space,    -   the processor being further programmed to repeat the generation        of the second set of data by:        -   adding, to the second and third set of data, data which            represent a component of a category and which are derived            from the first set of data, or        -   deleting data representing a component of the second and            third set of data, or        -   amending data representing a previously added component of            the second and third set of data,    -   while respecting the constraints associated with each component        and constraints for the assembly, so as to arrive at an updated        version of the second set of data, and at an updated version of        the third set of data.

The computer system may be programmed to perform the steps describedabove in connection with the method of the first aspect of theinvention.

In a third aspect the invention relates to a computer program productfor configuring, in a memory of a computer system, a virtualrepresentation of an assembly of a plurality of components, the computerprogram product comprising means for:

-   -   storing, in a database of the computer system, a first set of        data representing a plurality of categories of components, and,        for each category, parameters and constraints defining        limitations for configurations of each of the components within        each of the categories, whereby all parameters and components in        a category have common constraints,    -   generating a second set of data representing the assembly of a        plurality of components and representing a configuration space        of said plurality of components, and storing the second set of        data in a memory of the computer system, the step of generating        being performed while respecting the constraints associated with        each component and constraints for the assembly, and generating        a third set of data representing a present configuration in the        configuration space,    -   repeating the step of generating by:        -   adding, to the second and third set of data, data which            represent a component of a category and which are derived            from the first set of data, or        -   deleting data representing a component of the second and            third set of data, or        -   amending data representing a previously added component of            the second and third set of data,    -   while respecting the constraints associated with each component        and constraints for the assembly, so as to arrive at an updated        version of the second set of data, and at an updated version of        the third set of data.

The invention also relates to a computer readable data carrier loadedwith the computer program product, a computer readable data signalembodying data generated by the computer program product, and to acomputer system comprising memory or storage means loaded with thecomputer program product. The computer program product may comprisemeans for performing all or some of the steps described above and belowin connection with the method of the invention.

DETAILED DESCRIPTION OF THE INVENTION

The scientific problem addressed within configuration technologies is toconstruct and navigate in a dynamical state space of legal solution to agiven system. Abstractly speaking, to configure (a product) is theprocess of navigating the parameter space to arrive at one configuration(of the product).

A product is some system or physical object or group of objects, whichtogether constitutes some kind of whole. A buildable product is aproduct, which consists of a number of subproducts, which can be buildtogether (in some sense) to yield a whole.

In configuration terminology a product model (PM) is a description ofall parameters in the full system and a description of whichcombinations of parameter values are legal, and these represent legal(or valid) products in a configurator. In this terminology, theconfiguration process consists of navigating the parameter space spannedby the parameters while respecting rules of the product model yielding alegal configuration of the product.

Mathematically speaking, the product model describes a parameter spacehaving M^(N*P) values, each corresponding to one possible configurationof the product. Here is assumed that the system consisting of Psub-systems each having N parameters each of which again has M possiblevalues. If the P sub-systems are non-connected, then the parameter spaceis having (M^(N))*P values only. However, the sub-systems have somesub-spaces, where they are connected. Hence, the parameter space ishaving (M^((N +O))*P values; which is less complex that the systemM^(N*P) for a small number O, i.e. for small overlap of sub-systems. Inother words, by adding some extra parameters describing theconnectedness to each sub-product a less complex system is determined,and this is a great advantage when the number P of sub-systems is notknown initially.

In the present invention, the componentized product model is inventedfor the purpose of describing an, in principle, infinite (or unlimited)parameter space (i.e. number of parameters), in which each component (Pabove) has a finite number of parameters (N above) each with a domain ofvalues (M above), while the full system may comprise an unlimited is notknown initially and can consist of any number of components. Thesecomponents are part of the data structure and each component isassociated with a number of state variables.

In a special case, a component is directly related to an object, whichhas a geometric representation. The object is normally a physical objectof the product and its geometry can be visualized in the associatedvisualization system on any device as a consequence of changes in thePM. Any electronic device, which can display the geometry can be usedfor visualization.

The classical assumption, that all parameters are the sum of all theparameters of all components is by definition infeasible to describe,since the product model in use is extended by building new components(model merging) to the existing componentized product model to yield anew configuration of the product.

An important concept of the present invention is state-basedconfiguration, which comprise a particular data structure representingthe parameter space, and an associated method to navigate the parameterspace (also called the state space).

In this method all parameters are represented by state variables, whichall have exactly one value at any time. The collection of values of allstate variables is called the state and represents exactly oneconfiguration of the product. Equally important, is the ability tonavigate in the parameter space by changing one (or more) variable at atime, until arriving at a satisfactory configuration. In a sense, thistype of configurator enables the user to move around in the parameterspace. The alternative is to narrow down some acceptable subset of theparameter space, and only at the very end arrive at one particularconfiguration of the product.

Consider products, which are physical in a sense, for example ascaffold. One benefit of the state representation is that it enablespresenting the configuration visually to a user during the configurationprocess. By visualization of a virtual representation of a product ismeant a visualization of the product, and not some abstract showing ofthe parameter space. The problems involving configuring a product and atthe same time display the result is a known problem in field ofconfiguration technology. Notice that state based configuration is inthe very core of how this type of configurator works and itsimplications and benefits are not at all restricted to thevisualization.

A central part of the invention is the concept of having a componentizedproduct model (componentized PM). The componentized PM consists of twoPM-related parts. One part is the static description of the PM and theother part is dynamic. This is necessary for the usefulness inapplications that involve building a product from individual componentsIn the PM and the full product changes dynamically, and consequently the(necessarily static) description of the model have to be separated fromthe model itself.

The static description is called the fragmentized product model, and itconsists of a finite number of PM-fragments. PM-fragments are thebuilding blocks of the PM. Each PM-fragment contains a set of productparameters.

A PM-fragment is a building block in the PM context whereas a componentis a building block in the product context. However, a PM-fragment isoften associated directly with a component or a component group.

The dynamic description is called the instant product model and itcontains a set of PM-fragments combined. In other words, the instant PMis the sum of its PM-fragments in a unique combination depending on eachother. Note that the instant PM normally includes many PM-fragments ofthe same category, where PM-fragments of the same category is defined asPM-fragments with the same set of parameters, but where the parametersmay have different values.

In summary, the componentized PM consists of the fragmentized PM and theinstant PM as illustrated in FIG. 1.

In a runtime environment using the componentized PM, the first instanceis a PM-fragment, which initializes the instant PM. Thereafter, changesin the componentized PM are done by model changing of the instant PM,and each change usually yields a new structure of the instant PM and/orits PM-fragments.

The whole foundation of being able to do this relies on a localcombination yielding what is call a PM-clustering in which allPM-fragments are put into their contexts. This implies that the impactof a particular component, or rather its state, is only local. At least,only local direct impact, since the change in its own cluster (context)may feasibly propagate to other clusters, through the cluster overlaps.

The invention relates to configuring a complex system, which may bebuild up from a plurality of system components (components for short).To distinguish, the entire system is called the scene.

To configure in a state based system means changing the state, whilerespecting the rules of a product model. The product model (of a system)in a configurator comprises a description for all parameters available,and the rules they must obey. Mathematically, it comprises a parameterspace, which is a Cartesian product of all the involved parameters

Individual domains, and a set of rules, essentially describing a subsetof the parameter space called the legal parameter space.

In relation to configurators, each point in the parameter space iscalled a configuration of the system in question, and if this point isin the valid subset this configuration is said to be legal (or valid).To configure (a system) comprise generating data representing one (orpossibly multiple) configuration. Note that a configuration (point inthe parameter space) comprises exactly one value of each parameter.

The meaning of a state based process approach to configuring is that theconfiguration process basically consists of navigating fromconfiguration (called states) to configuration by making changes statevariables, each representing individual parameters, one or more at atime, usually all the time staying within the legal subset.

In a given state of the entire system, the intersection between thelegal parameter space and the domain of a parameter is called the legalvalues of the parameter. These are exactly the values which thisvariable may be assigned without creating a conflict with anothervariable, i.e. breaking a rule.

Essentially, there are three separate data structures involved in themethod:

-   -   1st set of data: A fragmentized product model, which is a set of        definitions of component categories (model-fragments), each        comprising data defining the number and sorts of parameters for        this category of component, and the behaviors of such a        component.    -   2nd set of data: An instantaneous product model, which is the        product model of the presently assembled system, comprising a        representation of all the parameters of the components in the        scene, and the subset of parameter space, which is presently        legal.    -   3rd set of data: A state, which exactly point out the present        point in the parameter space (representing the present        configuration).

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a conceptual drawing of a componentized product model,

FIG. 2 contains an overview of the steps in a process for settingvalues,

FIG. 3 shows a propagate value step of the process for setting values,

FIG. 4 shows a process value step of the process for setting values,

FIG. 5 illustrates constraints between components through a separatedata structure,

FIG. 6 shows a check value step of the process for setting values,

FIG. 7 illustrates a state-based method divided into different statesduring the process for setting values,

FIG. 8 illustrates a component and its state vector with statevariables,

FIG. 9 shows a cluster of C3, which involves C2 and C4,

FIG. 10 illustrates a set of overlapping clusters, wherein the clusterof C1 contains only two components,

FIG. 11 illustrates an example of a more complex cluster structure withsubcomponents,

FIG. 12 illustrates adding a component (component 5), which extends theparameter space,

FIG. 13 illustrates the process of adding a component to the instantproduct model,

FIG. 14 shows the process of connection components,

FIG. 15 illustrates model chaining as a result of a connection betweentwo components,

FIG. 16 illustrates the architecture of a component-based visualconfigurator,

FIG. 17 contains a drawing of data-structures of manager, world,components etc.,

FIG. 18 shows a logic cluster of component 1,

FIG. 19 shows a visualization of the steps in configuring a scaffoldingsystem,

FIG. 20 shows a cluster of platform 4 including some of the variablesinvolved,

FIG. 21 shows the assembly (or component hierarchy) as it appears afterstep 10 of the configuration process,

FIG. 22 shows the parameter space of the configured scaffolding system.

DETAILED DESCRIPTION OF THE DRAWINGS

The state variable represents exactly one parameter in the PM, and it isthe point, where the data and rules from the PM are directly connectedto the configuration process.

A state variable is associated with a domain, representing all thevalues available for this parameter. It does not make any sense toassign anything not in the domain to a variable.

At a given time a subset, possibly all, of the domain values are said tobe legal, while the rest is illegal. This is something that changesdynamically, contrary to the domain, which is static. Notice, whichvalues are legal at a given time reflects the PM's reaction to thepresent state, that is, given the state of the entire system, whichvalues can be assigned this variable without bringing the entire systemin an illegal state. Thus, indirectly it reflects the variablesinteraction with other variables.

As mentioned, a state value has exactly one value at any time, and theterm the variable is set with the value is used. This value is one ofmany in the domain, and only the set value process can change it. Anoverview of each step in the set value process is given in FIG. 2. Ifthe set value process results in an illegal state, the process is saidto go into conflict, see the propagate value step in FIG. 3. Dependingon the explicit settings of the system this may be resolved in differentways. One example is to use simple rollback of the variable in question,another is to call the entire state transient and exploit the quiteadvanced transient state resolution mechanism, to identify which othervariables values should be adjusted to give a legal state.

A state variable can be assigned a number of constraints, which candynamically limit which of the domain values are legal. In other words,the constraints control which values are legal. Moreover, a statevariable can be assigned a number of consequences or effects, which aretriggered during the set value process in the process value step, seeFIG. 4.

The rules determining the legal part of the parameter space are modeledby assigning constraints to each state variables. A constraint can beconsidered kind of a link to a separate data structure or even anexternal data structure, in which information of particular aspects ofthe current system is collected and processed, see FIG. 5. Eachconstraint is then a particular interpretation of this information,which is relevant for a particular state variable. For example, having adata structure representing purely geometric information of a system ofobjects allows the use of constraints representing geometric propertiesof the system. Another example is some calculation done in the separateexternal data structure, which in turn affects the parameter space viathe state variables. A third example of a separate data structure is adatabase with all legal combinations of a given (local) system ofvariables, i.e. a logic configurator of the system.

An important point here is that the constraint is assigned to exactlyone state variable, which is then indirectly linked to its datastructure, but the data structure can, and usually does, have multiplestate variables thus linked to it. This is exactly how state variablescan interact with each other; not directly, but through their respectivereactions to changes in such a data structure.

Apart from constraining the legal values of a state variable, allconstraints have a consequence or effect upon its data structure,meaning that the data structure changes upon setting a state variablewith a constraint associated. This is the mechanism for assigning aconsequence or effect to a state variable.

In practical use, a constraint is simulatable, if it is possible tocheck the legality of a value without taking the consequences of it.This is usually just a question of performance of the particularimplementation, and thus not really relevant to the abstract process. Itis mentioned, because it is of such a great importance in a practicalimplementation of the method. See FIG. 6 for flow of the check valuestep.

Thus, if a constraint is not simulatable it cannot be checked beforesome effects are triggered. If a value is found to be illegal in such asituation, the state value is in conflict, and a rollback mechanism isperformed. The most common rollback mechanism is just to reverse thesetting procedure; however, this is not always possible and/or desirablein a given situation. Another rollback mechanism is using weightedschemes of effects where the effects have different priority accordingto the weighting given in the scheme.

The state-based method divided into its different states during the setvalue process is shown in FIG. 7.

When such a data structure has been thus changed, other variablesassociated with this data structure may have had their situationchanged, and should be notified. This is also handled by the constraint.Thus, a constraint can be alerted by changes in the associated datastructure, and can notify the state variable of such changes. Thereaction to such changes can be of different kinds, but there are somenoteworthy basics. In the first instance, it leads to updating thecurrently legal values, but it can also lead to actually setting thevalue of this variable.

Setting a single variable can lead to setting other variables via theconstraint-effects relation, which can in turn lead to setting othervariables, thus propagating the consequences. This process is calledeffect cascading (or just cascading). Note that this is not restrictedto staying within one PM fragment, it can very well spread out to theentire instant PM, though it very rarely does in practice, since it isvery wise to insert propagating stops to control this process.

A component is a part of the data structure (of a PM fragment) and eachcomponent is associated with a state vector comprising one statevariable for each of the components parameters, see FIG. 8. The effecton the component is controlled through these state variables. Forexample, if a particular state variable is set on a component, thiscould have a visual effect.

Recall that the component represents a product building block. An entire(complete or part of a) product is composed of a number of such blocksrepresented by a number of components. A product can be composed, bymaking pairwise connections between the subproducts. Fitting with thebuildable product concept, components can be pairwise connected yieldinga data-structure called the component hierarchy (or assembly), which ismathematical called a component graph.

Each component can have a (dynamically changing) number of connections(or structural connections) to other components. Connections arereflexive, so the connections are two-way, in the sense that if acomponent is connected to another, the other is also connected to thefirst. As noted earlier, part of the PM of a component is thecomponent's relations to other components, which may play a role to thegiven component, and often this will be modeled by having a particularstate variable, which has as its value another component. Thisparticular state variable is called a component variable. The actualvalue is a component category corresponding to a PM-fragment, while itstill holds the particular instance of a component category, which isthe component. To clarify, if a component (say C2) is the value of acomponent variable (say Neighbor1) in another component (say C1), thenC2 plays the role Neighbor1 in the PM of C1.

Within the PM of a component, a component variable is just a statevariable. However, (part of) the effect of (setting) a componentvariable is to establish a connection between its component and thevalue component. Note that this may include setting a variable in theother component with this component variable.

PM-fragments are the building blocks of the overall PM of a system. EachPM-fragment contains a set of parameters of the system. A PM-fragment isa building block in the PM context, and in many cases is the PM-fragmentequivalent to a component or a group of components.

Model chaining is the abstract process of combining a number ofPM-fragments in an instant PM. In practice, model chaining can takeplace over a structural connection (between components), and is the wayto make two PM-fragments talk to each other. This is also part ofpromoting the fragment into a part of a full instant PM (see FIG. 1 andFIG. 15).

On component level, all interaction between components in a componenthierarchy takes place using chaining, and chaining always takes. placewithin a cluster. This is essentially the definition of a cluster.

If two components are connected, one can establish chains between thestate variables.

Such chains establish some relation between the value of one statevariable and the other state variable. The relation can be of differentkinds, examples are one-way mirroring, sharing, and in logicimplementation, constraint transference. In abstract terms, as a wholethis constitutes what is usually known as model chaining the local PMsof the two components.

The simple situation is when the PM-fragments are independent of eachother. In general, the PM-fragments are highly dependent of each otherin a complex pattern. To control this pattern clustering is used.

In the runtime environment, all the PM-fragments are, at least inprinciple, combined into the Instant PM. In principle only, since thewhole foundation of being able to do this relies on a local combinationyielding what we call a PM-clustering in which all PM-fragments are putinto their contexts.

The concept of clusters Is an integrate part of a componentized PMtogether with model chaining. All components are associated with aPM-fragment. The model chaining comes into play when a component'sbehavior depends on its neighbor component's state variable. Thiscomplete PM-fragment of one component's behavior is called the local(componentized) product model. In principle, it can be dependent on anynumber of its neighbor components state variables or reach into anynumber of levels of neighbor's neighbors. This overlapping of statevariables in different local models, making them dependent, is exactlymodel chaining. The collection of components, which are involved In onelocal componentized product model, is called a cluster.

Thus, the instant PM, which is a global componentized product model,consists of the local models, which with the overlapping clusters yielda complete covering of all components. The components, which take partin multiple clusters, are the ones that are included in the modelchaining.

To give an example, imagine a category of component, which have twoneighbors, and imaging five of these linked in a chain. The local modelof one component depends on its neighbors, but nothing further. So thecluster of C3 involves C2 and C4, see FIG. 9. To illustrate how theglobal product model consists of overlapping clusters, see the completepicture in FIG. 10 for a product model with five components. Notice thatC1 and C5 only have one neighbor in this case, so in their clustersthere are only two components.

Very often the clustering will be much more complex, involving differentcategories of components, which are not all model chained. As a simpleextension of the previous example, consider if the components above havetwo subcomponents with one subcomponent each. The parent component'smodel depends on all its subcomponents, but neither of these isdepending on anything in clusters of C2 and C4 (see FIG. 11).

The instant product model compromises the dynamical product model, andincludes a set of PM-fragments build together. In other words, theinstant PM is the sum of its PM-fragments in a unique combinationdepending on each other.

Notice, that the instant PM normally includes many PM-fragments of thesame category, where PM-fragments of the same category is defined asPM-fragments with the same set of parameters, but where the parametersmay have different values.

Model merging is what happens when an instant PM is changed dynamicallyby adding a new PM-fragment to a given instant PM or when connecting twoor more components. In the first case, the present instant PM isextended with a new fragment. In the other case, merging of the instantPMs of each of the component is performed. However, In practice on thelocal level the processes are the same, thus the unified wording.

Model merging can be done in two ways. One way is within a clusterjoining the PM-fragments; however, this just assembles one completelocal PM, i.e. a new PM-fragment, in the cluster. The other way isbetween clusters, which is the real model chaining seen from the pointof view of general configuration.

A good way to look at an instant PM is as an (unlimited) number ofoverlapping classical product models, each of which can besemi-independently configured, except as they impact their overlaps bymodel merging.

A single component can be considered an instance of a componentcategory. Upon creating a component a new copy of all the parameters iscreated. Upon adding the component to the scene, all these parametersare added to the total instantaneous parameter space of the instant PM,and those constraints, which only involve that component, are applied.

When two components are connected, each plays a particular role towardseach other. These roles are predefined (with behavior and all) in thecomponent category and the behavior is part of product model.

The behavior can be seen as consisting of two parts. First part is adescription of which roles are available and which component categoriescan play them. The component variable represents each role available toa component. There is then a domain, as well as the optional constraintsassigned to this variable. Second part is a description of how the twolocal PMs associated with these components affect each other. Theyaffect each other by putting constraints on each other's statevariables, i.e. they do not affect which variables are actuallyavailable in the components, while they do affect which values are legalin those variables.

In this context, the instant PM comprises:

-   -   A parameter space, which is a Cartesian product of domains        associated with individual parameters (state variables).    -   A legal subset of the parameter space, which defines        relationships between the parameters values.

An equally valid way of looking at this is that the instant PM comprisesrelationships between the values of these parameters, defining a subsetof the parameter space, which is called legal. Such relationships arealso called constraints.

The instant PM may change dynamically, in the following manner. What maychange is:

-   -   The parameters, which are included in the parameter space. Note        that the domain of a given parameter may not change.    -   The subset of the parameter space, which is called legal. Note        that by definition a subset belongs to the superset, so changing        the parameter space a priori renders the subset invalid.        However, if defining extensions of the superset by just adding        to the legal subset, and restrictions as the obvious        restrictions of the subset, this is still well defined.

The instant PM (in the configurator) essentially changes when amending acomponent, when adding or removing a PM-fragment (or component), andwhen rearranging the connections between the PM-fragments in thecorresponding component hierarchy. It can change in five ways by

-   -   amending a component    -   adding a new component,    -   removing a component,    -   connecting two components,    -   and disconnecting two components        as explained in the following. The operation of amending a        component only has local effect on the parameters of the        component. The operation of adding a new component, extends the        parameter space by adding the parameters of the new component,        see FIG. 12. Furthermore, this subset may be constrained        internally, but there can be no relationships between these new        parameters and the old ones. The process of adding a component        to the instant PM is shown in FIG. 13.

The operation of removing a component simply removes the parameterassociated with this component from the parameter space of the instantPM. A pre-request is that the component to be removed is not connected,i.e. has been disconnected from all other components before.

The operation of connecting two components may change the legal subset.Directly by establishing new relationships between parameters belongingto each of the two components. Indirectly this may further haveconsequences on those parameters already established relationships.Concretely, the process involves establishing model chaining between thelocal PMs of the two components in question. This model chaining dependson, which particular roles the components play towards each other and isdescribed as part of the PM-fragments (component categories), see FIG.14.

One way to implement the process of connecting two components involvesmaking each of the components play a particular role towards the other,and setting up the model chaining between the two components. This modelchaining consists of establishing a chain or more chains betweenelements belonging to the two local PM-fragments of the components (seeFIG. 15). These chains are associated with the particular roles, and arepart of the PM-fragment.

Obviously, the operation of disconnecting two components requires thatthese two components be connected. This operation changes the legalsubset by disconnecting all relationships between parameters belongingto these components.

A componentized PM consists of two PM-related parts. One part is thestatic description of the PM called the fragmentized PM, which consistsof a finite number of PM-fragments. The other part is the instant PMdescribed above, which is changed dynamically in a run-time environment.

These two parts are important to separate, since the fragmentized PM isuse for getting a structure of building blocks of a system or productbefore it is build together, whereas the instant PM is used in the buildprocess, where each PM-fragment from the fragmentized PM is used ingenerating the instant PM.

A very important effect of connecting two components, and establishingmodel chaining as described, is that this merges the two PMs, and thuschanges both in the model merging process. In principle, seen as astandard configurator, this renders the whole configuration, whichsatisfies the Instant PM from before the merge, invalid or even notmeaningful. However, by the componentized PM based on the principle ofcomponent-centered state representation of the current configuration, itis ensured that the number of variables, their meaning, and theassociated domains are unchanged ensuring the very important propertythat the resulting state still represents a meaningful (technicallyvalid) configuration in the new, merged componentized PM.

This property described above is a very important property, but thestates' legality here is not guaranteed. This state is a transientstate, since the illegalities need to be resolved, and in this case purerollback would not be appropriate, since this would correspond tobreaking the connection again. This is called transient resolution, andthere are a several possibilities. Note that even though in principleall variables may have become illegal, by the locality principlesnaturally build into the component-centered representation (e.g. bothgeometric and structural locality) usually the problems would beconfined to the neighborhood of the involved components, and very oftenjust a very few variables, if any at all.

The strategy to solve transient resolution based on componentized PM, isto find an acceptable state nearby in the parameter space. How tomeasure the term nearby depends on the PM, and can in fact be consideredpart of the componentized PM. This could for instance be assigning apriority to all variables and change the least important ones inconflict first until a legal state is reached. Other strategies arepossible.

In principle, a component variable is just an ordinary variable, whichcan have constraints in the normal fashion. However, since setting sucha variable actually cause a model merging implying that the ruleschanges during the value setting process, where it have to becoordinated in the PM on both sides before the merging, and to prevent atoo extensive transient resolution, plug technology is employed. Plugtechnology pre-ensures some compatibility between the connected PMs.Plugs, basically, represent connection points in the components, and byassociating with the component variables, they control if connectionsmake sense, before the PMs are merged. A further benefit is that this Isa natural way of providing geometric and visual representation withnecessary positioning data.

EXAMPLE OF A COMPONENT-BASED VISUAL CONFIGURATOR

The invention gives a method for configuring a virtual representation ofphysical objects in a component-based visual configurator based on theprinciple that a product and thus the product model can be infinitelybuild from subproducts (or product parts). The componentized productmodel is used as a fundamental mechanism in the component-based visualconfigurator, in short: The visual configurator. This visualconfigurator is made for a type of products typically hard to handlewith a standard configurator, and on the other hand commonly occurring.Conceptually, it is binding together the following 5 key points;

-   -   1. employing a component hierarchy and    -   2. a state engine, which is a particular implementation of the        state representation,    -   3. binding to it a dynamic, true visual representation of the        current configuration,    -   4. and satisfying both logic constraints    -   5. and geometric constraints.

The basic architecture of a component-based visual configurator is shownin FIG. 16. The description below is concentrated on the overall datastructure selected, which set into perspective with the data structuresdescribed earlier, together with particular implementation choices inrelation to state variable process timing done by the state engine, andthe working and association of constraints in connection with the statevariables.

The basic structure multitude of components connected in a graphstructure (not necessarily a single connection group). Each component isassigned a state vector; comprising one state variable for each of thecomponents parameters. This constitutes a complete representation of the(dynamic) parameter space.

The visualization is added by assigning the world some surroundings (thevisual world), assigning each component a visual representation, andallowing each state variable of a component to have a visual effect,changing the components representation (including its position relativeto the world or other components). Since each state variable has exactlyone value at all times the complete visualization of the entire productexactly shows the current configuration at all times.

The rules determining the legal part of the parameter space, are modeledby assigning constraints to each state variables. In this implementationtwo particular types of such constraints are used. One is a purelygeometric representation of the world and product, which allows the useof constraints representing geometric properties of the product. Thegeometric rules are added similarly to the visualization, by assigningthe world some geometric world, allowing each component a geometricrepresentation, and allowing each state variable a geometric constraint.The component structure is reflected in the fact that each connectionbetween components encompasses a relative position between them.

Second type is a normal logic configurator, which collect a purely logicrepresentation of the product. There is associated such one for eachlocal PM-fragment, which is associated with a certain category ofcomponent called logic cluster holder, depending on the particular PM,this could in principle be every component. In particular statevariables are bound together by assigning them logic constraintsassociated with some logical description of relations between thevariables. In this implementation each component is allowed to beassociated with such one, and each state variables may be assigned alogic constraint binding it to one (see more details on how this relatesto the concepts of local product model, logic cluster and cluster holderbelow).

First of all, the full application comprises a core containing the above(and below) described methods and structures, together with a 3Drenderer (any device), a graphical user-interface, possibly an externallogic configurator, and a representation of the PM in question.

The basic application structure is build up of a number of controllers,basically, an overall manager to bind everything together and handleinitialization, a data-manager to control the static fragmentized PM andassociated information (data), a visual controller to handle the 3Dvisualization, which interfaces with an external visualization system,and a geometry controller to handle the geometric world.

The overall data structure (apart from specialized ones in each of theabove) is build up around the multiple components. There is a world,which essentially represents the surroundings, i.e. the scene in whichthe product is build. It contains the components, which may be directlyinserted into it, but not the component hierarchy directly. Only someinitially components are directly inserted into the world, whilesubcomponents for instance may be connected to another component, andthus only indirectly inserted. This data structure is sketched in FIG.17.

The next three examples describe the three parts under the state enginein FIG. 16.

EXAMPLE OF THE VISUALIZATION PART

To maintain a true visualization of the current (full) configuration(state of the product), the following practical aspects have to be takeninto consideration.

First of all, a visual scene is associated through the visual controllerto the world object represented, for example by some 3D-scene graph.This also contains the product surroundings, which may again have itsown parameters and can in fact be configured separately. Thisdistinction is made, since it will usually just influence the product orthe PM (rules), instead of actually being a part of the product.Sometimes it may even be changed visually just to show the actualconfiguration in right or correct surroundings.

Secondly, each component can be assigned a visual representation.Non-visual components are referred to as ghost components or abstractcomponents, and usually have some collecting role.

Thirdly, each state variable may have a visual effect, which influencesa specific aspect of that representation. It might in fact just exchangethe entire representation with another depending on the flexibility ofthe visualization system.

A possible type of visualization systems is one where the representationis build on a scene graph or even a 3D scene graph. In such a system,the visual effect of one variable of a component will be to make changesto a particular visual node. For instance changing the color-field of amaterial node may change the color of an item, while changing the shapenode may change the actual shape of it. Changing the translation orrotation field of a transform node further up the graph will change theposition of the item, i.e. move the component.

This hierarchical representation is particularly well suited to exploitthe benefits of the componentized representation in use. It makes itnatural and easy to contain visual changes locally, i.e. within acomponent or just between two connected components. For instance, twocomponents can be visually bound together in a connection, independentlyof other component, and without affecting relations to other components.Again the point of component-based visual configuration is thatconsequences (and effects) can be effectuated locally. In other words,on the components own visual representation and the positions ofconnections to other components.

EXAMPLE OF CONSTRAINTS IN A GEOMETRIC CONFIGURATOR

An important part of a visual configurator describing physical objectsis the ability to describe geometric and physical aspects of theproduct, and relate these aspects to the configurator, i.e. the statevariables.

Similarly to the visualization, the idea essentially is to maintain ageometric representation of the current (full) configuration. Thus, Itis possible to assign constraints to a state variable, which can querythe current geometric representation, and also change it, which normallyimplies an effect.

Again, each component can be assigned a geometric representationdetermined (its shape), which is inserted in the geometric world whenthe component is added to the current configuration. Each variable canbe assigned a geometric constraint, which for instance could prevent acomponent to be moved on top of another, i.e. collision prevention, orperhaps ensure that nothing enters a particular zone associated with acomponent. An example of a zone is a safety zone or a working zone. Itcould also just be having some slots which can be occupied or not, andthus prevent or allow components needing a particular set of slots frombeing inserted or connected.

The concept of geometric constraints is particularly important for theconfigurator, in that via the geometric world there can be given senseto concepts like distance between components, which can actually bemeasured and employ in other rules, e.g. logic ones. This is not datausually available to a classic configurator, which makes certain typesof rules hard to formulate. Also it gives a natural concept of localinfluence (locality or nearness) totally apart from the structural one(of the component structure and component hierarchy), which for instanceallows a very simple way of noticing or sensing when subproducts havebeen added and/or build to meet again. This way of formulating geometricrules is a key mechanism of the componentized PM.

Notice that all geometric constraints are associated to the samegeometric world, meaning their respective state variables are hereinfluencing each other totally independently of whether they can accessthe same state vector, i.e. locally with respect to the componentstructure. Instead, being of a geometrical nature, a constraint on acomponent is only influenced by others, which are physically near thecomponent. Hence, there is a different concept of geometric localityhere, which beautifully complements the structural one.

EXAMPLE OF LOGIC CONSTRAINTS IN A COMPONENTIZED CONFIGURATOR

A range of problems is solved in combining logic configuration with theconcepts of componentized configuration, and thus exploits the power ofa logic configurator in the componentized environment. In other words,this environment enhances the logic configurator and vice versa, if usedright.

Essentially, the data structure is extended by being allowed toassociate a logic configurator (logic-database) to each component (statevector actually), containing logical rules, and assigning logicconstraints of this database to state variables in the component. Thisallows these variables to become inter-dependent in a complex way(dependent on the complexity allowed in the logic-database).

By using the chaining mechanism, state variables in connected componentscan also be assigned logic constraint from the same logic-database, andthus encompassing them in the corresponding local product model. In thissituation, the multitude of variables, which have been assigned logicconstraints from this database, is called the logic cluster of thecomponent with the associated logic-database. This component is thencalled the logic cluster holder (see FIG. 18). Note that this structureallows the configurator to exploit the strength of any logicconfigurator. In the componentized configurator the local product modelsdescribes a predetermined number of parameters, while the entire,instant product model may comprise any number of local product modelsand thus any number of parameters.

EXAMPLE OF A VISUAL CONFIGURATOR FOR A SCAFFOLDING SYSTEM

The purpose of this example is to illustrate the configuration processusing the methods of the present invention. The component structure anddata structure of input data used in the configurator is emphasized, andhow the componentization of the product model (PM) captures theextendable nature of a so-called buildable product.

The example is a scaffolding system. Two aspects are examined, namelythe modeling process, where the structure, parameters and rules of thesystem is captured, and the configuration process, where a particularscaffold is configured, exploiting and respecting the limitations of thescaffolding system.

The scaffold configurator could for instance be offered by ascaffold-system manufacturer, as a service for scaffolders, who can usethe system to configure exactly the scaffold they need for a particulartask, while ensuring that the manufacturer can actually deliver such a(customized) system. Using the visualization-system associated with theconfigurator, i.e. a visual configurator, this will be very easy for thescaffolder to assembly correctly.

The product consists of an entire system for building scaffolds. Itcomprises a number of sub-scaffolding items, such as floor modules,rails, ladders etc. These are denoted components In the product modeland (physical) objects in the sub-product context. Recall that a productmodel also can contain abstract components, and that these do notnecessarily correspond one-to-one to physical objects.

In more details, the scaffolding system in mind is a system for settingup a working platform up along the side of some building. Essentially,it consists of a number of floor platforms mounted on a frame structureof steel tubes. To facilitate going up and down some floors can haveholes with ladders mounted. To protect workers from falling, rails ofsteel tubes can be mounted on the frames as well. Finally, (and notmodeled here) the frame can be attached to the wall of the building tofixate It.

A scaffold is essentially build from a number of floor modules,comprising both platform and the necessary frame. There are two types ofplatforms, one standard and one with a hole and ladder mounted. Theplatform is rectangular with a short side and a wide side, and thescaffold can be build out from floor modules by connecting other floormodules to either side (equal lengths required) or on top or below.

Usually, one of the two wide sides of a module will be the wall mountand is called the inside-side. Below a module there have to be eitherground or another module. The distance from one floor module to the nextabove can be low, medium or high (and a possible ladder from a hole hasto abide by this height). A given scaffold (one configuration) isdivided into stories, so platforms next to each other have the sameheight.

There are two types of rails, a short and a wide, fitting with the sidesof the floor module. To allow adding rails on the top-most floor it ispossible to add a top module, essentially consisting of some longertubes.

The particular system of scaffold has a PM comprising the followingcomponents; platform, rail standard, rail full, top and ladder withrelations as described above. Below is specified the parameters of eachtype of component, and a formulation of them as variables according tothe componentized PM. Moreover, the chaining involved between differentconnections is formulated. Thirdly, sketched are the constraintsinvolved defined as associated to a rules database (here namedrules.logicdb), and sketch the type of rule involved.

There are two types of floor modules, one standard and one with a holeand ladder mounted. These correspond to one (platform) component in thePM, which can either. have or not have a hole in either side of thefloor. Notice that if it can only have hole in one end the orientationmatters. On the other hand, there cannot be two holes. The platformcomponent is the key component in this product model, which collects therules and parameters of the scaffold system.

TABLE 1 The platform component <Component id=platform . . .  <variables>  <var id=neighbor_left domain=modules valuetype=component type=link . ..   <var id=neighbor_right . . .   <var id=neighbor_outsidedomain=modules type=link . . .   <var id=inside_neighbor . . .   <varid=above domain=modules_and_top type=link    . . . here should be achain if the module comprised different ‘shapes’ of modules,    . . . egwide and narrow   <var id=below . . .   <var id=laddervaluetype=component type=sub . . .    <chain id=resize direction=outconstraint=ladder chained=length/>   </var>   <var id=rail_leftdomain=rails type=sub    <chain id=“length” direction=“out”constraint=“rail_left_length” chained=“length”/>   </var>   <varid=rail_right domain=rails type=sub . . .    . . .   <varid=rail_outside domain=rails type=sub . . .    . . .   <varid=rail_inside domain=rails type=sub . . .    . . .   <varid=wall_inside valuetype=boolean default=true   <var id=heightvaluetype=integer domain=module_heights default=medium   <var id=holevaluetype=boolean visualeffect=switch  </variables>  <logic>    . . . </logic>  <geometry>    . . .  </geometry> </Component>

TABLE 2 The rail standard component <Component id=rail_standard  <varid=length domain=side_lengths </Component>

TABLE 3 The full rail component <Component id=rail_full  <var id=lengthdomain=side_lengths </Component>

TABLE 4 The top component <Component id=top . . .   <var id=rail_leftdomain=rails type=sub   <var id=rail_right domain=rails type=sub   <varid=rail_outside domain=rails type=sub   <var id=rail_inside domain=railstype=sub   <var id=wall_inside valuetype=boolean </component>

TABLE 5 The ladder component  <Component id=ladder   <var id=lengthdomain=module_heigths effect=switch </Component>

TABLE 6 The domains of the variables <domain id=moduleslist=(platform,none)/> <domain id=modules_and_toplist=(platform,top_module,none)/> <domain id=rails list=(rail_standard,rail_full, none)/> <domain id=module_heights  list=(low, medium, high)/><domain id=side_lengths  list=(short, wide)/>

The following rules are used to describe the product model:

-   Rule 1. The connection points of two modules have to be of the same    length, i.e. if C 1 have C2 as left_neighbor, then C2 has to have C1    as either right_neighbor or left_neighbor, and furthermore, it has    to be right because otherwise the inside-sides would not correspond.-   Rule 2. There can be no inside neighbor if there is a wall.-   Rule 3. If a floor is not on the ground there have to be another    floor below.-   Rule 4. There can only be a ladder if there is a hole.-   Rule 5. If the floor is not on the ground there have to be a rail on    a floors side, if there is no neighbor (or wall if inside).-   Rule 6. As a consequence of rule 5 there has to be something on top    of every floor component (recall the tubing goes down from the    platform).-   Rule 7. Similarly to rule 1, the length variable of the rail has to    correspond to the length of the floor side.-   Rule 8. A ladder's length has to fit with the modules' height-   Rule 9. The height of all the floors neighbors (not above and below)    must be the same.-   Rule 10. No collision of objects or collision with the surroundings,    for instance a part of the building.-   Rule 11. The geometry of a ladder and rail has to fit with the    length (and only if there is no collision).

Rule 1 is essentially a structural constraint of coordinating whichroles two components in a connection each play. This is implementedusing plugs making the constraint implicit.

TABLE 7 Connecting of modules using plug constraints <varid=neighbor_left plugid=neighbor_left . . . <plug id=neighbor_lefttype=floor_short . . .   . . .

Rule 2, rule 3 and rule 4 are standard logic-type constraint bindingvariables within a component together. Each of the variables isassociated with a constraint, thus binding it to a logic data-structure(rules.logicdb), which can be formulated separately.

TABLE 8 Logic-type constraints associated to a rules database namedrules.logicdb <var id=neighbor_inside logicconstraint=neighbor_inside .. . <var id=wall logiccconstraint=wall . . .  . . . <logicdatabase=rules.logicdb . . .  <constraint id=neighbor_inside <constraint id=ladder  <constraint id=wall  <constraint id=below</logic>

In the separate data structure rules.logicdb, the rules are formulatelogically:

TABLE 9 Logical rules, where -> means implies wall=true -> inside=nonehole=false -> ladder=none onground=false -> below=floor_module

Rule 5 and rule 6 are similar to rule 2, rule 3 and rule 4, except thatit is very impractical to enforce these rules during the buildingprocess. For instance, the empty side is a necessary pre-state to addanother floor-module. This type of rules is called a complete rule orfinalize rule, and is only enforced by the system if explicitly asked tocomplete. When enforced the configurator yields a final and correctscaffold.

TABLE 10 Logical rules, where ! means not in_complete ->(neighbor_left=none and !ground) -> rail_left !=none in_complete ->(neighbor_outside=none and !ground) -> rail_outside!=none        . . .in_complete -> above!=none

Rule 7 and rule 8 are also standard logic-type constraints, except theyinvolve variables in different connected components. Since logicconstraints are held by one component it is necessary to push theconstraints from the floor-module onto the variables of respectivelyrail and ladder through the chaining mechanism.

TABLE 11 Relation between chains, logic and components <componentid=floor_module  <var id=rail_outside . . .   <chain id=lengthconstraint=rail_outside.length  </var>  <logic database=rules.logicdb>  <constraint id=rail_outside.length . . .  </logic> </component><component id=rail . . .  <var id=parent   <chain chaintype=constraint <var id=length . . . and in ‘rules.logicdb’ rail_outside!=none ->rail_outside.length=wide rail_left!=none -> rail_left.length=narrow . .. ladder.length=platform.height

Rule 9 is equal type constraints between connected components. This canbe handled directly through the chaining mechanism

TABLE 12 Chaining mechanism <var id=neighbor_left domain=modulesvaluetype=component type=link . . .  <chain id=n_height direction=inchained=myheight  constraint=neighbor_left.height  <chain id=myheightdirection=out chained=n_height refvar=height  . . . or . . .  <chainid=myheight direction=out chained=n_height constraint=height </var><logic database=rules.logicdb>  <constraint id=neighbor_left.height andin ‘rules.logicdb’ add platform.height=neighbor_left.heightplatform.height=neighbor_outside.height  . . .

Rule 10 and rule 11 are typical collision-type constraints. Rule 10 isimplicit formulated on all component variables by assigning geometry tothe components. For example,

TABLE 13 Collision geometry on a component <component id=rail . . . <geometry>   <box size= . . .. position=. . ..  </geometry>

Rule 11 involves telling the geometric data-structure that the geometryof a component changes (and checks whether this is allowable). This istypical geometric constraint.

TABLE 14 Geometric constraint on a component <component id=rail . . . <var id=length geometricconstraint=length . . .  . . .  <geometry>  <constraint id=length type=geometrychange . . .  </geometry>  . . .</component>

In the following is given an example of how to configure a scaffold in acomponentized configuration system using the componentized product modeldefined above. The focus is twofold; first to show the process and how auser can exploit the benefits of this way of configuring a product.Second to give show what actually happens within the configurator duringthe configuration process.

The target configuration is a scaffold in two floored levels forinstance to reach a particular window needing some outside renovation,with ladders in one side, giving a 2 ×2 scaffold with extra top moduleson both. The user takes the following steps and the correspondingvisualization of each step is illustrated in FIG. 19:

-   Step 1: The only component available for direct insertion into the    world is the platform, so the user selects and inserts a platform.    It comes in the default height medium. It is automatically named    platform1.-   Step 2: The user selects the left_side of platform1 accessing the    two variables neighbor_left and rail_left. One can add either a    platform or a rail. The user adds the platform, which is named    platform2.-   Step 3: The user selects platform2 and set the variable hole to    true. The configuration system will automatically add a ladder    (downwards) at the hole (ladder1), and sets its length to medium.-   Step 4: Now select the top of platform2. One can add either a    platform or a top module. The user adds the platform (named    platform3).-   Step 5: The user sets the variable hole to true in platform3,    automatically adding ladder2.-   Step 6: Selecting the top and add a top (top1).-   Step 7: Noticing the top floor is not high enough to reach the    window, and the user selects platform3 and adjusts the variable    height to high. The length of ladder2 is automatically set to the    value high too.-   Step 8: Select the top of platforms, and the user can add another    platform (platform4). This is noted by the geometric world, and the    system automatically set platform4 as neighbor_right to platform3.    It subsequently adjusts its height variable to the value high.-   Step 9: To have optimal protection of workers climbing the ladders,    the user selects the outside of platform3 and set outside_rail to    the value full. It comes in with length variable equal to the value    wide.-   Step 10: Finally, to ensure railing all necessary places the process    complete is enforced by the user. The configuration system adds    single rails to platform3 via the state variable rail_left,    platform4 via rail_right and rail_outside and top1 via rail_left and    rail_outside, adds a top (top2) to platform4.above, adds single    rails to top2 rail_right and rail_outside. Note that by default the    inside of both platform and top is along wall, so nothing is added    there.

What actually happens within the configurator during the configurationprocess is discussed in the following focusing on the instantaneous PM,the state, the cluster-concept, and the rollback-mechanism.

Recall that the instant PM is a model of the currently assembledconfiguration of components, representing all the possible changes onecan perform on the (current) state. It comprises the current componenthierarchy describing how the components are assembled, and it comprisesthe current state space describing the collection of all state variablesand their possible values. In FIG. 21 is shown the complete componenthierarchy after step 10 is completed. In addition, recall that the staterepresents uniquely the current configuration, in the sense that itrepresents exactly one point within the current state space, and thecurrent instant PM is reproducible from the state together with the(data of the) static fragmentized PM.

The state is exactly the collection of the values of all the statevariables, where some variables (the component variables) play a dualrole, as their value is related to and defines a connection to anothercomponent, and their collected states defines the component hierarchy.Their value in this respect is not a state value, but an actualcomponent. This is called their connection value. In FIG. 22 is shown asketch of the state space after step 9 is completed, and the state atthe same time (see also FIG. 12). Notice that all variables have adefault value, so they cannot be without a value. Variables, which haveno specified default will automatically select one as the default, inparticular component variables have the value none as default.

Recall that the (logic-) cluster is the part of the instant PM, which isdirectly constrained by one logic structure. In this example only theplatforms has a logic structure (rules) attached, so after all steps hasbeen completed there are four (logic) clusters; one for each platform.See FIG. 20 for an illustration of the cluster of platform4 after step10 has been completed. This figure illustrates the variables constrainedby the logic structure attached to platform4 (platform4 is clusterholder). Notice that it includes some variables in other component,which are thus chained into the platform4 cluster. On FIG. 20 these areshown in separate boxes with lines going to the connection variablethrough which it is chained. Notice also that the variableneighbor_left.height is from platform3, which has its own cluster. Thisis an example of cluster overlap, where this information is needed bothplaces.

Next is considered the process of setting a variable with a value. Instep 3 the variable hole in platform2 is set to true. Usually, thisworks something like:

-   1) The user-interface accesses platform2 and obtains hole from it.-   2) It asks for a list of legal values, which here is (true, false).-   3) The user invokes the set value process on hole with the value    true:-   4) First the legality is checked and verified.-   5) Secondly, the value is processed. This step includes updating the    visual world to show the hole, and telling the logical    data-structure of the new value.-   6) Thirdly, the value is propagated. Here this involves finding    possible consequences in the logical data-structure.-   7) It discovers a simple conflict, namely with the other variable    ladder, whose current value, none, is not among the presently legal    values (ladder).-   8) The state engine goes into resolving state.-   9) To resolve the conflict the state engine invokes set value    processing on the variable ladder with the value ladder.-   10) When the ladder variable has successfully been set there are no    more conflicts so the state engine goes to ready.-   11)This set value process is finished successfully and notifies the    user (-interface) of the new value.

Now is considered setting a component variable, i.e. creating a newconnection. Above in step 9 the variable set was a component variable,so setting it has the side effect of actually creating a new component(ladder1), which is added to the instant PM, and connected to platform2.Normally, this works as follows:

-   1) Set variable ladder with value ladder.-   2) Check if it is legal. It is.-   3) Process the value. This invokes special effects for component    variables.-   4) Create a new component of type ladder. This becomes ladder1.-   5) Initialize the state of ladder1. This consists of setting the    sole variable length to the default value medium.-   6) Connect it to the world (depending on the exact setup of the    visual configurator)-   7) Connect the chain resize to the variable length through the    connector-variable ladder in the component platform2.-   8) Check for conflicts in the ladder component. None found here.-   9) Return from the connection process, and continue to the propagate    value of the ladder variable in platform2, which checks for any    conflicts. None found here either so the state engine can go into    ready and return.

Finally, consider resolving conflicts. Notice in step 7 the configuratorpurposely changed the height of plaform2 yielding a conflict with thelength of ladder1, which is then caught and resolved. A similarsituation occurs in Step 3 and 5, which works as follows:

-   1) First the process check legality will find and tell that the    value is illegal. The user has to explicitly override this (by    listening to the abort-state of the variable and revoke it). In this    case, the user-interface would do this automatically.-   2) Secondly, the rollback-procedure should allow it to proceed. This    will start the resolution procedure in the process propagate value.-   3) By propagate value the conflict in the logic-cluster will be a    reality. It will find that the variables height and ladder.length is    in conflicting, and will find all possible resolutions, and finally    compare them. In our example, the state engine selects changing    ladder.length over height, since height's constraint has just been    user-overridden. This could also have been done by setting the    priority of height explicitly higher than ladder.length. In other    cases, the user or surrounding application could be asked.

1. A method for configuring, in a memory of a computer system, a virtual representation of an assembly of a plurality of components, the method comprising the steps of: storing, in a database of the computer system, a first set of data representing a plurality of categories of components, and, for each category, parameters and constraints defining limitations for configurations of each of the components within each of the categories, whereby all components in a category have common parameters and constraints, generating a second set of data representing the assembly of a plurality of components and representing a configuration space of said plurality of components, the second set of data comprising a separate data structure which defines valid combinations of components, the separate data structure being included in the second set of data in such a way that each separate data structure is associated with a particular component, whereby the constraints of the particular component reflects said valid combinations of components, storing the second set of data in a memory of the computer system, the step of generating being performed while respecting the constraints associated with each component and constraints for the assembly, generating a third set of data representing a present configuration in the configuration space, the step of generating the third set of data comprising offering a plurality of components or component categories, repeating the steps of generating a second set of data and generating a third set of data by: offering only such components which, when added to the assembly, result in a valid combination of components, the offered components being derived from the separate data structure of the second set of data, adding, to the second and third set of data, data which represent one of the offered components and which are derived from the first set of data, or deleting data representing a component of the second and third set of data, or amending data representing a previously added component of the second and third set of data, while respecting the constraints associated with each component and constraints for the assembly, so as to arrive at an updated version of the second set of data, and at an updated version of the third set of data, wherein at least one of the step of generating the second set of data and the third set of data comprises creating a set of clusters, each cluster containing data representing a single component as well as optionally at least one further component which is connected to said single component, whereby the set of clusters contains data representing all components comprised in the virtual representation.
 2. A method according to claim 1, wherein data representing the plurality of components further comprise data representing parameters of the components, the method further comprising, at the step of generating the third set of data, offering a plurality of parameters of components, whereby only selected parameters are offered, the selected parameters being selected in accordance with constraints of components in such a way that only possible and/or legal combinations of components and parameters are achievable.
 3. A method according to claim 1, wherein, at the step of offering components, only components are offered which respect constraints associated with each component and constraints for the assembly.
 4. A method according to claim 1, the method further comprising visualizing, on a display device or printer associated with the computer system, a graphical or physical representation of at least a part of the configuration space represented by the second set of data.
 5. A method according to claim 1, the method further comprising visualizing, on a display device or printer associated with the computer system, a graphical or physical representation of at least a part of the configuration represented by the third set of data.
 6. A method according to claim 1, wherein the computer system is connected to a communications network, the method further comprising: sending the second and/or the third set of data, via the communications network, to a further computer system, and visualizing, on a monitor of said further computer system or any other device for displaying, a graphical image of the configuration space represented by the second set of data and/or a graphical image of the configuration represented by the third set of data.
 7. A method according to claim 1, wherein the second set of data comprises data representing relationships between related components whereby the second set of data also represents connections between components.
 8. A method according to claim 1, wherein the step of adding comprises connecting components in the assembly and/or adding a component to the assembly.
 9. A method according to claim 1, wherein the step of deleting comprises disconnecting two components in the assembly and/or removing a component from the assembly.
 10. A method according to claim 1, wherein the step of amending comprises at least one of: amending data representing at least one component of the assembly, connecting two components of the assembly, and disconnecting two components of the assembly.
 11. A method according to claim 1, wherein the separate data structure associated with said single component defines possible or allowed combinations of components of the cluster and/or parameter values of the components of the cluster.
 12. A method according to claim 1, wherein the separate data structure constitutes a configuration database in which data representing possible or allowed combinations of components and/or parameter values are stored.
 13. A method according to claim 1, wherein the separate data structure constitutes possible or allowed combinations of components and/or parameter values derived from a computation.
 14. A method according to claim 1, wherein the step of generating the second set of data comprises: performing, for each cluster, a check of whether the data representing the single component of that cluster, is compatible with constraints defined by mutually connected components in that cluster, and if the check reveals non-compatibility: amending the second set of data and/or the data representing the single component in question while respecting constraints conferred of mutually connected components.
 15. A method according to claim 1, wherein the second set of data comprises data representing a geometry of at least a part of the assembly, whereby the constraints of the components of said part of the assembly define constraints of a geometric nature on the parameters of the components.
 16. A method according to claim 1, wherein the third set of data represents a state of a present configuration, the method comprising, at the step of repeating, automatically updating the second set of data in response to changes to the third set of data.
 17. A method according to claim 16, wherein the present configuration is reproducible from the first and third set of data.
 18. A computer system for configuring, in a memory of the computer system, a virtual representation of an assembly of a plurality of components, the computer system comprising: a database storing a first set of data representing a plurality of categories of components, and, for each category, parameters and constraints defining limitations for configurations of each of the components within each of the categories, whereby all components in a category have common parameters and constraints, a processor which is programmed to generate a second set of data representing the assembly of a plurality of components and representing a configuration space of said plurality of components, and to store the second set of data in a memory of the computer system, the second set of data comprising a separate data structure which defines valid combinations of components, the separate data structure being included in the second set of data in such a way that each separate data structure is associated with a particular component, whereby the constraints of the particular component reflects said valid combinations of components, the processor being programmed to generate the second set of data while respecting the constraints associated with each component and constraints for the assembly, the processor being further programmed to generate a third set of data representing a present configuration in the configuration space, the processor being further programmed to repeat the generation of the second set of data by: offering only such components which, when added to the assembly, result in a valid combination of components, the offered components being derived from the separate data structure of the second set of data, adding, to the second and third set of data, data which represent one of the offered components and which are derived from the first set of data, or deleting data representing a component of the second and third set of data, or amending data representing a previously added component of the second and third set of data, while respecting the constraints associated with each component and constraints for the assembly, so as to arrive at an updated version of the second set of data, and at an updated version of the third set of data, wherein the processor is programmed to, in the memory of the computer system, create a set of clusters, each cluster containing data representing a single component as well as optionally at least one further component which is connected to said single component, whereby the set of clusters contains data representing all components comprised in the virtual representation.
 19. A computer system according to claim 18, wherein data representing the plurality of components further comprise data representing parameters of the components, the processor being further programmed to, when generating the third set of data, offering a plurality of parameters of components, whereby only selected parameters are offered, the selected parameters being selected in accordance with constraints of components in such a way that only possible and/or legal combinations of components and parameters are achievable.
 20. A computer system according to claim 18, wherein the processor is further programmed to only offer components and/or parameter values, which respect constraints associated with each component and constraints for the assembly.
 21. A computer system according to claim 18, the computer system being connected to a display device or printer for visualizing a graphical or physical representation of at least a part of the configuration space represented by the second set of data.
 22. A computer system according to claim 18, the computer system being connected to a display device or printer for visualizing a graphical or physical representation of at least a part of the configuration represented by the third set of data.
 23. A computer system according to claim 18, the computer system being connected to a communications network, the computer system further comprising: a communication interface for sending the second and/or the third set of data, via the communications network, to a further computer system connected to a display device for visualizing a graphical image of the configuration space represented by the second set of data and/or a graphical image of the configuration represented by the third set of data.
 24. A computer system according to claim 18, wherein the processor is further programmed to, when adding data to the second and third set of data, connecting components in the assembly and/or adding a component to the assembly.
 25. A computer system according to claim 18, wherein the processor is further programmed to, when deleting data from the second and third set of data, disconnecting two components in the assembly and/or removing a component from the assembly.
 26. A computer system according to claim 18, wherein the processor is further programmed to, when amending the second and third set of data, perform at least one of: amending data representing at least one component of the assembly, connecting two components of the assembly, and disconnecting two components of the assembly.
 27. A computer system according to claim 18, wherein the processor is programmed to, at the step of generating the second set of data: perform, for each cluster, a check of whether the data representing the single component of that cluster, is compatible with constraints defined by mutually connected components in that cluster, and if the check reveals non-compatibility: amend the second set of data and/or the data representing the single component in question while respecting constraints conferred of mutually connected components.
 28. A computer system according to claim 18, wherein the third set of data represents a state of the present configuration, the processor being further programmed to, at the step of repeating, automatically update the second set of data in response to changes to the third set of data.
 29. A computer readable medium, storing computer executable instructions that provide a virtual representation of an assembly of a plurality of components, the instructions, which when executed on a computer system perform the steps of: storing, in a database of the computer system, a first set of data representing a plurality of categories of components, and, for each category, parameters and constraints defining limitations for configurations of each of the components within each of the categories, whereby all components in a category have common parameters and constraints, generating a second set of data representing the assembly of a plurality of components and representing a configuration space of said plurality of components, the second set of data comprising a separate data structure which defines valid combinations of components or parameter values, the separate data structure being included in the second set of data in such a way that each separate data structure is associated with a particular component, whereby the constraints of the particular component reflects said valid combinations of components or parameter values, storing the second set of data in a memory of the computer system, the step of generating being performed while respecting the constraints associated with each component and constraints for the assembly, and generating a third set of data representing a present configuration in the configuration space, the step of generating comprising offering a plurality of components or component categories, repeating the steps of generating a second set of data and generating a third set of data by: offering only such components which, when added to the assembly, result in a valid combination of components, the offered components being derived from the separate data structure of the second set of data, adding, to the second and third set of data, data which represent one of the offered components and which are derived from the first set of data, or deleting data representing a component of the second and third set of data, or amending data representing a previously added component of the second and third set of data, while respecting the constraints associated with each component and constraints for the assembly, so as to arrive at an updated version of the second set of data, and at an updated version of the third set of data, wherein at least one of the step of generating the second set of data and the third set of data comprises creating a set of clusters, each cluster containing data representing a single component as well as optionally at least one further component which is connected to said single component, whereby the set of clusters contains data representing all components comprised in the virtual representation. 